juce/source/extras/the jucer/src/ui/jucer_PaintRoutineEditor.cpp

   1 /*
   2   ==============================================================================
   3
   4    This file is part of the JUCE library - "Jules' Utility Class Extensions"
   5    Copyright 2004-11 by Raw Material Software Ltd.
   6
   7   ------------------------------------------------------------------------------
   8
   9    JUCE can be redistributed and/or modified under the terms of the GNU General
  10    Public License (Version 2), as published by the Free Software Foundation.
  11    A copy of the license is included in the JUCE distribution, or can be found
  12    online at www.gnu.org/licenses.
  13
  14    JUCE is distributed in the hope that it will be useful, but WITHOUT ANY
  15    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  16    A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
  17
  18   ------------------------------------------------------------------------------
  19
  20    To release a closed-source product which uses JUCE, commercial licenses are
  21    available: visit www.rawmaterialsoftware.com/juce for more information.
  22
  23   ==============================================================================
  24 */
  25
  26 #include "../jucer_Headers.h"
  27 #include "jucer_PaintRoutineEditor.h"
  28 #include "../model/jucer_ObjectTypes.h"
  29 #include "jucer_JucerDocumentHolder.h"
  30
  31
  32 //==============================================================================
  33 PaintRoutineEditor::PaintRoutineEditor (PaintRoutine& graphics_,
  34                                         JucerDocument& document_,
  35                                         JucerDocumentHolder* const docHolder)
  36     : graphics (graphics_),
  37       document (document_),
  38       documentHolder (docHolder),
  39       componentOverlay (0),
  40       componentOverlayOpacity (0.0f)
  41 {
  42     refreshAllElements();
  43
  44     setSize (document.getInitialWidth(),
  45              document.getInitialHeight());
  46 }
  47
  48 PaintRoutineEditor::~PaintRoutineEditor()
  49 {
  50     document.removeChangeListener (this);
  51
  52     removeAllElementComps();
  53
  54     removeChildComponent (&lassoComp);
  55     deleteAllChildren();
  56 }
  57
  58 void PaintRoutineEditor::removeAllElementComps()
  59 {
  60     for (int i = getNumChildComponents(); --i >= 0;)
  61     {
  62         PaintElement* const e = dynamic_cast <PaintElement*> (getChildComponent (i));
  63
  64         if (e != 0)
  65             removeChildComponent (e);
  66     }
  67 }
  68
  69 const Rectangle<int> PaintRoutineEditor::getComponentArea() const
  70 {
  71     if (document.isFixedSize())
  72     {
  73         return Rectangle<int> ((getWidth() - document.getInitialWidth()) / 2,
  74                                (getHeight() - document.getInitialHeight()) / 2,
  75                                document.getInitialWidth(),
  76                                document.getInitialHeight());
  77     }
  78     else
  79     {
  80         return Rectangle<int> (editorEdgeGap, editorEdgeGap,
  81                                getWidth() - editorEdgeGap * 2,
  82                                getHeight() - editorEdgeGap * 2);
  83     }
  84 }
  85
  86 //==============================================================================
  87 void PaintRoutineEditor::paint (Graphics& g)
  88 {
  89     const Rectangle<int> clip (getComponentArea());
  90
  91     g.setOrigin (clip.getX(), clip.getY());
  92     g.reduceClipRegion (0, 0, clip.getWidth(), clip.getHeight());
  93
  94     graphics.fillWithBackground (g, true);
  95     grid.draw (g, &graphics);
  96 }
  97
  98 void PaintRoutineEditor::paintOverChildren (Graphics& g)
  99 {
 100     if (componentOverlay.isNull() && document.getComponentOverlayOpacity() > 0.0f)
 101         updateComponentOverlay();
 102
 103     if (componentOverlay.isValid())
 104     {
 105         const Rectangle<int> clip (getComponentArea());
 106         g.drawImageAt (componentOverlay, clip.getX(), clip.getY());
 107     }
 108 }
 109
 110 void PaintRoutineEditor::resized()
 111 {
 112     if (getWidth() > 0 && getHeight() > 0)
 113     {
 114         componentOverlay = Image();
 115         refreshAllElements();
 116     }
 117 }
 118
 119 void PaintRoutineEditor::updateChildBounds()
 120 {
 121     const Rectangle<int> clip (getComponentArea());
 122
 123     for (int i = 0; i < getNumChildComponents(); ++i)
 124     {
 125         PaintElement* const e = dynamic_cast <PaintElement*> (getChildComponent (i));
 126
 127         if (e != 0)
 128             e->updateBounds (clip);
 129     }
 130 }
 131
 132 void PaintRoutineEditor::updateComponentOverlay()
 133 {
 134     if (componentOverlay.isValid())
 135         repaint();
 136
 137     componentOverlay = Image();
 138     componentOverlayOpacity = document.getComponentOverlayOpacity();
 139
 140     if (componentOverlayOpacity > 0.0f)
 141     {
 142         if (documentHolder != 0)
 143             componentOverlay = documentHolder->createComponentLayerSnapshot();
 144
 145         if (componentOverlay.isValid())
 146         {
 147             componentOverlay.multiplyAllAlphas (componentOverlayOpacity);
 148             repaint();
 149         }
 150     }
 151 }
 152
 153 void PaintRoutineEditor::visibilityChanged()
 154 {
 155     document.getUndoManager().beginNewTransaction();
 156
 157     if (isVisible())
 158     {
 159         refreshAllElements();
 160         document.addChangeListener (this);
 161     }
 162     else
 163     {
 164         document.removeChangeListener (this);
 165         componentOverlay = Image();
 166     }
 167 }
 168
 169 void PaintRoutineEditor::refreshAllElements()
 170 {
 171     int i;
 172     for (i = getNumChildComponents(); --i >= 0;)
 173     {
 174         PaintElement* const e = dynamic_cast <PaintElement*> (getChildComponent (i));
 175
 176         if (e != 0 && ! graphics.containsElement (e))
 177             removeChildComponent (e);
 178     }
 179
 180     Component* last = 0;
 181
 182     for (i = graphics.getNumElements(); --i >= 0;)
 183     {
 184         PaintElement* const e = graphics.getElement (i);
 185
 186         addAndMakeVisible (e);
 187
 188         if (last != 0)
 189             e->toBehind (last);
 190         else
 191             e->toFront (false);
 192
 193         last = e;
 194     }
 195
 196     updateChildBounds();
 197
 198     if (grid.updateFromDesign (document))
 199         repaint();
 200
 201     if (currentBackgroundColour != graphics.getBackgroundColour())
 202     {
 203         currentBackgroundColour = graphics.getBackgroundColour();
 204         grid.updateColour();
 205         repaint();
 206     }
 207
 208     if (componentOverlayOpacity != document.getComponentOverlayOpacity())
 209     {
 210         componentOverlay = Image();
 211         componentOverlayOpacity = document.getComponentOverlayOpacity();
 212         repaint();
 213     }
 214 }
 215
 216 void PaintRoutineEditor::changeListenerCallback (ChangeBroadcaster* source)
 217 {
 218     refreshAllElements();
 219 }
 220
 221 void PaintRoutineEditor::mouseDown (const MouseEvent& e)
 222 {
 223     if (e.mods.isPopupMenu())
 224     {
 225         PopupMenu m;
 226
 227         m.addCommandItem (commandManager, CommandIDs::editCompLayout);
 228         m.addCommandItem (commandManager, CommandIDs::editCompGraphics);
 229         m.addSeparator();
 230
 231         for (int i = 0; i < ObjectTypes::numElementTypes; ++i)
 232             m.addCommandItem (commandManager, CommandIDs::newElementBase + i);
 233
 234         m.show();
 235     }
 236     else
 237     {
 238         addChildComponent (&lassoComp);
 239         lassoComp.beginLasso (e, this);
 240     }
 241 }
 242
 243 void PaintRoutineEditor::mouseDrag (const MouseEvent& e)
 244 {
 245     lassoComp.toFront (false);
 246     lassoComp.dragLasso (e);
 247 }
 248
 249 void PaintRoutineEditor::mouseUp (const MouseEvent& e)
 250 {
 251     lassoComp.endLasso();
 252
 253     if (e.mouseWasClicked() && ! e.mods.isAnyModifierKeyDown())
 254     {
 255         graphics.getSelectedElements().deselectAll();
 256         graphics.getSelectedPoints().deselectAll();
 257     }
 258 }
 259
 260 void PaintRoutineEditor::findLassoItemsInArea (Array <PaintElement*>& results, const Rectangle<int>& lasso)
 261 {
 262     for (int i = 0; i < getNumChildComponents(); ++i)
 263     {
 264         PaintElement* const e = dynamic_cast <PaintElement*> (getChildComponent (i));
 265
 266         if (e != 0 && e->getBounds().expanded (-e->borderThickness, -e->borderThickness)
 267                                     .intersects (lasso))
 268             results.add (e);
 269     }
 270 }
 271
 272 SelectedItemSet <PaintElement*>& PaintRoutineEditor::getLassoSelection()
 273 {
 274     return graphics.getSelectedElements();
 275 }
 276
 277 bool PaintRoutineEditor::isInterestedInFileDrag (const StringArray& files)
 278 {
 279     const File f (files [0]);
 280
 281     return f.hasFileExtension ("jpg")
 282         || f.hasFileExtension ("jpeg")
 283         || f.hasFileExtension ("png")
 284         || f.hasFileExtension ("gif")
 285         || f.hasFileExtension ("svg");
 286 }
 287
 288 void PaintRoutineEditor::filesDropped (const StringArray& filenames, int x, int y)
 289 {
 290     const File f (filenames [0]);
 291
 292     if (f.existsAsFile())
 293     {
 294         Drawable* d = Drawable::createFromImageFile (f);
 295
 296         if (d != 0)
 297         {
 298             delete d;
 299
 300             document.getUndoManager().beginNewTransaction();
 301
 302             graphics.dropImageAt (f,
 303                                   jlimit (10, getWidth() - 10, x),
 304                                   jlimit (10, getHeight() - 10, y));
 305
 306             document.getUndoManager().beginNewTransaction();
 307         }
 308     }
 309 }